﻿namespace ICMRemoteEdu.Forms
{
    using System;
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Data;
    using System.Diagnostics;
    using System.IO;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.Serialization;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Serialization;

    [Serializable, ToolboxItem(true), XmlRoot("Info"), DesignerCategory("code"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedDataSetSchema"), HelpKeyword("vs.data.DataSet")]
    public class Info : DataSet
    {
        private System.Data.SchemaSerializationMode _schemaSerializationMode;
        private DataRelation relationFK_Question_UserAnswers;
        private DataRelation relationFK_User_UserAnswers;
        private CompanyDataTable tableCompany;
        private QuestionDataTable tableQuestion;
        private UserDataTable tableUser;
        private UserAnswersDataTable tableUserAnswers;

        [DebuggerNonUserCode]
        public Info()
        {
            this._schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            base.BeginInit();
            this.InitClass();
            CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
            base.Tables.CollectionChanged += handler;
            base.Relations.CollectionChanged += handler;
            base.EndInit();
        }

        [DebuggerNonUserCode]
        protected Info(SerializationInfo info, StreamingContext context) : base(info, context, false)
        {
            this._schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            if (base.IsBinarySerialized(info, context))
            {
                this.InitVars(false);
                CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
                this.Tables.CollectionChanged += handler;
                this.Relations.CollectionChanged += handler;
            }
            else
            {
                string s = (string) info.GetValue("XmlSchema", typeof(string));
                if (base.DetermineSchemaSerializationMode(info, context) == System.Data.SchemaSerializationMode.IncludeSchema)
                {
                    DataSet dataSet = new DataSet();
                    dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                    if (dataSet.Tables["Company"] != null)
                    {
                        base.Tables.Add(new CompanyDataTable(dataSet.Tables["Company"]));
                    }
                    if (dataSet.Tables["User"] != null)
                    {
                        base.Tables.Add(new UserDataTable(dataSet.Tables["User"]));
                    }
                    if (dataSet.Tables["Question"] != null)
                    {
                        base.Tables.Add(new QuestionDataTable(dataSet.Tables["Question"]));
                    }
                    if (dataSet.Tables["UserAnswers"] != null)
                    {
                        base.Tables.Add(new UserAnswersDataTable(dataSet.Tables["UserAnswers"]));
                    }
                    base.DataSetName = dataSet.DataSetName;
                    base.Prefix = dataSet.Prefix;
                    base.Namespace = dataSet.Namespace;
                    base.Locale = dataSet.Locale;
                    base.CaseSensitive = dataSet.CaseSensitive;
                    base.EnforceConstraints = dataSet.EnforceConstraints;
                    base.Merge(dataSet, false, MissingSchemaAction.Add);
                    this.InitVars();
                }
                else
                {
                    base.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                }
                base.GetSerializationData(info, context);
                CollectionChangeEventHandler handler2 = new CollectionChangeEventHandler(this.SchemaChanged);
                base.Tables.CollectionChanged += handler2;
                this.Relations.CollectionChanged += handler2;
            }
        }

        [DebuggerNonUserCode]
        public override DataSet Clone()
        {
            Info info = (Info) base.Clone();
            info.InitVars();
            info.SchemaSerializationMode = this.SchemaSerializationMode;
            return info;
        }

        [DebuggerNonUserCode]
        protected override XmlSchema GetSchemaSerializable()
        {
            MemoryStream w = new MemoryStream();
            base.WriteXmlSchema(new XmlTextWriter(w, null));
            w.Position = 0L;
            return XmlSchema.Read(new XmlTextReader(w), null);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
        {
            Info info = new Info();
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = info.Namespace;
            sequence.Items.Add(item);
            type.Particle = sequence;
            XmlSchema schemaSerializable = info.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            base.DataSetName = "Info";
            base.Prefix = "";
            base.Namespace = "http://tempuri.org/Info.xsd";
            base.EnforceConstraints = true;
            this.SchemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            this.tableCompany = new CompanyDataTable();
            base.Tables.Add(this.tableCompany);
            this.tableUser = new UserDataTable();
            base.Tables.Add(this.tableUser);
            this.tableQuestion = new QuestionDataTable();
            base.Tables.Add(this.tableQuestion);
            this.tableUserAnswers = new UserAnswersDataTable();
            base.Tables.Add(this.tableUserAnswers);
            ForeignKeyConstraint constraint = new ForeignKeyConstraint("Company_FK", new DataColumn[] { this.tableCompany.IDColumn }, new DataColumn[] { this.tableUser.Company_IDColumn });
            this.tableUser.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.Cascade;
            constraint.UpdateRule = Rule.Cascade;
            constraint = new ForeignKeyConstraint("FK_Question_UserAnswers", new DataColumn[] { this.tableQuestion.IDColumn }, new DataColumn[] { this.tableUserAnswers.QUESTION_IDColumn });
            this.tableUserAnswers.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.Cascade;
            constraint.UpdateRule = Rule.Cascade;
            constraint = new ForeignKeyConstraint("FK_User_UserAnswers", new DataColumn[] { this.tableUser.IDColumn }, new DataColumn[] { this.tableUserAnswers.USER_IDColumn });
            this.tableUserAnswers.Constraints.Add(constraint);
            constraint.AcceptRejectRule = AcceptRejectRule.None;
            constraint.DeleteRule = Rule.Cascade;
            constraint.UpdateRule = Rule.Cascade;
            this.relationFK_Question_UserAnswers = new DataRelation("FK_Question_UserAnswers", new DataColumn[] { this.tableQuestion.IDColumn }, new DataColumn[] { this.tableUserAnswers.QUESTION_IDColumn }, false);
            this.Relations.Add(this.relationFK_Question_UserAnswers);
            this.relationFK_User_UserAnswers = new DataRelation("FK_User_UserAnswers", new DataColumn[] { this.tableUser.IDColumn }, new DataColumn[] { this.tableUserAnswers.USER_IDColumn }, false);
            this.Relations.Add(this.relationFK_User_UserAnswers);
        }

        [DebuggerNonUserCode]
        protected override void InitializeDerivedDataSet()
        {
            base.BeginInit();
            this.InitClass();
            base.EndInit();
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.InitVars(true);
        }

        [DebuggerNonUserCode]
        internal void InitVars(bool initTable)
        {
            this.tableCompany = (CompanyDataTable) base.Tables["Company"];
            if (initTable && (this.tableCompany != null))
            {
                this.tableCompany.InitVars();
            }
            this.tableUser = (UserDataTable) base.Tables["User"];
            if (initTable && (this.tableUser != null))
            {
                this.tableUser.InitVars();
            }
            this.tableQuestion = (QuestionDataTable) base.Tables["Question"];
            if (initTable && (this.tableQuestion != null))
            {
                this.tableQuestion.InitVars();
            }
            this.tableUserAnswers = (UserAnswersDataTable) base.Tables["UserAnswers"];
            if (initTable && (this.tableUserAnswers != null))
            {
                this.tableUserAnswers.InitVars();
            }
            this.relationFK_Question_UserAnswers = this.Relations["FK_Question_UserAnswers"];
            this.relationFK_User_UserAnswers = this.Relations["FK_User_UserAnswers"];
        }

        [DebuggerNonUserCode]
        protected override void ReadXmlSerializable(XmlReader reader)
        {
            if (base.DetermineSchemaSerializationMode(reader) == System.Data.SchemaSerializationMode.IncludeSchema)
            {
                this.Reset();
                DataSet dataSet = new DataSet();
                dataSet.ReadXml(reader);
                if (dataSet.Tables["Company"] != null)
                {
                    base.Tables.Add(new CompanyDataTable(dataSet.Tables["Company"]));
                }
                if (dataSet.Tables["User"] != null)
                {
                    base.Tables.Add(new UserDataTable(dataSet.Tables["User"]));
                }
                if (dataSet.Tables["Question"] != null)
                {
                    base.Tables.Add(new QuestionDataTable(dataSet.Tables["Question"]));
                }
                if (dataSet.Tables["UserAnswers"] != null)
                {
                    base.Tables.Add(new UserAnswersDataTable(dataSet.Tables["UserAnswers"]));
                }
                base.DataSetName = dataSet.DataSetName;
                base.Prefix = dataSet.Prefix;
                base.Namespace = dataSet.Namespace;
                base.Locale = dataSet.Locale;
                base.CaseSensitive = dataSet.CaseSensitive;
                base.EnforceConstraints = dataSet.EnforceConstraints;
                base.Merge(dataSet, false, MissingSchemaAction.Add);
                this.InitVars();
            }
            else
            {
                base.ReadXml(reader);
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        private void SchemaChanged(object sender, CollectionChangeEventArgs e)
        {
            if (e.Action == CollectionChangeAction.Remove)
            {
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeCompany()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeQuestion()
        {
            return false;
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeRelations()
        {
            return false;
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeTables()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeUser()
        {
            return false;
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeUserAnswers()
        {
            return false;
        }

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), DebuggerNonUserCode]
        public CompanyDataTable Company
        {
            get
            {
                return this.tableCompany;
            }
        }

        [DebuggerNonUserCode, Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public QuestionDataTable Question
        {
            get
            {
                return this.tableQuestion;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), DebuggerNonUserCode]
        public DataRelationCollection Relations
        {
            get
            {
                return base.Relations;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible), Browsable(true), DebuggerNonUserCode]
        public override System.Data.SchemaSerializationMode SchemaSerializationMode
        {
            get
            {
                return this._schemaSerializationMode;
            }
            set
            {
                this._schemaSerializationMode = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), DebuggerNonUserCode]
        public DataTableCollection Tables
        {
            get
            {
                return base.Tables;
            }
        }

        [Browsable(false), DebuggerNonUserCode, DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public UserDataTable User
        {
            get
            {
                return this.tableUser;
            }
        }

        [DebuggerNonUserCode, Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public UserAnswersDataTable UserAnswers
        {
            get
            {
                return this.tableUserAnswers;
            }
        }

        [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class CompanyDataTable : DataTable, IEnumerable
        {
            private DataColumn columnID;
            private DataColumn columnName;

            public event Info.CompanyRowChangeEventHandler CompanyRowChanged;

            public event Info.CompanyRowChangeEventHandler CompanyRowChanging;

            public event Info.CompanyRowChangeEventHandler CompanyRowDeleted;

            public event Info.CompanyRowChangeEventHandler CompanyRowDeleting;

            [DebuggerNonUserCode]
            public CompanyDataTable()
            {
                base.TableName = "Company";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal CompanyDataTable(DataTable table)
            {
                base.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    base.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    base.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    base.Namespace = table.Namespace;
                }
                base.Prefix = table.Prefix;
                base.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected CompanyDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
            {
                this.InitVars();
            }

            [DebuggerNonUserCode]
            public void AddCompanyRow(Info.CompanyRow row)
            {
                base.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public Info.CompanyRow AddCompanyRow(string Name)
            {
                Info.CompanyRow row = (Info.CompanyRow) base.NewRow();
                object[] objArray2 = new object[2];
                objArray2[1] = Name;
                object[] objArray = objArray2;
                row.ItemArray = objArray;
                base.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                Info.CompanyDataTable table = (Info.CompanyDataTable) base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new Info.CompanyDataTable();
            }

            [DebuggerNonUserCode]
            public Info.CompanyRow FindByID(short ID)
            {
                return (Info.CompanyRow) base.Rows.Find(new object[] { ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return base.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(Info.CompanyRow);
            }

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                XmlSchemaComplexType type = new XmlSchemaComplexType();
                XmlSchemaSequence sequence = new XmlSchemaSequence();
                Info info = new Info();
                XmlSchemaAny item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                item.MinOccurs = 0M;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                XmlSchemaAny any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                any2.MinOccurs = 1M;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                XmlSchemaAttribute attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = info.Namespace;
                type.Attributes.Add(attribute);
                XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "CompanyDataTable";
                type.Attributes.Add(attribute2);
                type.Particle = sequence;
                XmlSchema schemaSerializable = info.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    MemoryStream stream = new MemoryStream();
                    MemoryStream stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema) enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type;
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnID = new DataColumn("ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnID);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                base.Constraints.Add(new UniqueConstraint("CompanyPK", new DataColumn[] { this.columnID }, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.Unique = true;
                this.columnName.Caption = "Наименование учреждения";
            }

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnID = base.Columns["ID"];
                this.columnName = base.Columns["Name"];
            }

            [DebuggerNonUserCode]
            public Info.CompanyRow NewCompanyRow()
            {
                return (Info.CompanyRow) base.NewRow();
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new Info.CompanyRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                if (this.CompanyRowChanged != null)
                {
                    this.CompanyRowChanged(this, new Info.CompanyRowChangeEvent((Info.CompanyRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                if (this.CompanyRowChanging != null)
                {
                    this.CompanyRowChanging(this, new Info.CompanyRowChangeEvent((Info.CompanyRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                if (this.CompanyRowDeleted != null)
                {
                    this.CompanyRowDeleted(this, new Info.CompanyRowChangeEvent((Info.CompanyRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                if (this.CompanyRowDeleting != null)
                {
                    this.CompanyRowDeleting(this, new Info.CompanyRowChangeEvent((Info.CompanyRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            public void RemoveCompanyRow(Info.CompanyRow row)
            {
                base.Rows.Remove(row);
            }

            [Browsable(false), DebuggerNonUserCode]
            public int Count
            {
                get
                {
                    return base.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IDColumn
            {
                get
                {
                    return this.columnID;
                }
            }

            [DebuggerNonUserCode]
            public Info.CompanyRow this[int index]
            {
                get
                {
                    return (Info.CompanyRow) base.Rows[index];
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class CompanyRow : DataRow
        {
            private Info.CompanyDataTable tableCompany;

            [DebuggerNonUserCode]
            internal CompanyRow(DataRowBuilder rb) : base(rb)
            {
                this.tableCompany = (Info.CompanyDataTable) base.Table;
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return base.IsNull(this.tableCompany.NameColumn);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                base[this.tableCompany.NameColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public short ID
            {
                get
                {
                    return (short) base[this.tableCompany.IDColumn];
                }
                set
                {
                    base[this.tableCompany.IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableCompany.NameColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Name' in table 'Company' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableCompany.NameColumn] = value;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class CompanyRowChangeEvent : EventArgs
        {
            private DataRowAction eventAction;
            private Info.CompanyRow eventRow;

            [DebuggerNonUserCode]
            public CompanyRowChangeEvent(Info.CompanyRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public Info.CompanyRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }
        }

        public delegate void CompanyRowChangeEventHandler(object sender, Info.CompanyRowChangeEvent e);

        [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class QuestionDataTable : DataTable, IEnumerable
        {
            private DataColumn columnID;
            private DataColumn columnName;
            private DataColumn columnNum;

            public event Info.QuestionRowChangeEventHandler QuestionRowChanged;

            public event Info.QuestionRowChangeEventHandler QuestionRowChanging;

            public event Info.QuestionRowChangeEventHandler QuestionRowDeleted;

            public event Info.QuestionRowChangeEventHandler QuestionRowDeleting;

            [DebuggerNonUserCode]
            public QuestionDataTable()
            {
                base.TableName = "Question";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal QuestionDataTable(DataTable table)
            {
                base.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    base.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    base.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    base.Namespace = table.Namespace;
                }
                base.Prefix = table.Prefix;
                base.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected QuestionDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
            {
                this.InitVars();
            }

            [DebuggerNonUserCode]
            public void AddQuestionRow(Info.QuestionRow row)
            {
                base.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public Info.QuestionRow AddQuestionRow(string Name, short Num)
            {
                Info.QuestionRow row = (Info.QuestionRow) base.NewRow();
                object[] objArray2 = new object[3];
                objArray2[1] = Name;
                objArray2[2] = Num;
                object[] objArray = objArray2;
                row.ItemArray = objArray;
                base.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                Info.QuestionDataTable table = (Info.QuestionDataTable) base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new Info.QuestionDataTable();
            }

            [DebuggerNonUserCode]
            public Info.QuestionRow FindByID(short ID)
            {
                return (Info.QuestionRow) base.Rows.Find(new object[] { ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return base.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(Info.QuestionRow);
            }

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                XmlSchemaComplexType type = new XmlSchemaComplexType();
                XmlSchemaSequence sequence = new XmlSchemaSequence();
                Info info = new Info();
                XmlSchemaAny item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                item.MinOccurs = 0M;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                XmlSchemaAny any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                any2.MinOccurs = 1M;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                XmlSchemaAttribute attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = info.Namespace;
                type.Attributes.Add(attribute);
                XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "QuestionDataTable";
                type.Attributes.Add(attribute2);
                type.Particle = sequence;
                XmlSchema schemaSerializable = info.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    MemoryStream stream = new MemoryStream();
                    MemoryStream stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema) enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type;
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnID = new DataColumn("ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnID);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnNum = new DataColumn("Num", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnNum);
                base.Constraints.Add(new UniqueConstraint("QuestionPK", new DataColumn[] { this.columnID }, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.Unique = true;
            }

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnID = base.Columns["ID"];
                this.columnName = base.Columns["Name"];
                this.columnNum = base.Columns["Num"];
            }

            [DebuggerNonUserCode]
            public Info.QuestionRow NewQuestionRow()
            {
                return (Info.QuestionRow) base.NewRow();
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new Info.QuestionRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                if (this.QuestionRowChanged != null)
                {
                    this.QuestionRowChanged(this, new Info.QuestionRowChangeEvent((Info.QuestionRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                if (this.QuestionRowChanging != null)
                {
                    this.QuestionRowChanging(this, new Info.QuestionRowChangeEvent((Info.QuestionRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                if (this.QuestionRowDeleted != null)
                {
                    this.QuestionRowDeleted(this, new Info.QuestionRowChangeEvent((Info.QuestionRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                if (this.QuestionRowDeleting != null)
                {
                    this.QuestionRowDeleting(this, new Info.QuestionRowChangeEvent((Info.QuestionRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            public void RemoveQuestionRow(Info.QuestionRow row)
            {
                base.Rows.Remove(row);
            }

            [DebuggerNonUserCode, Browsable(false)]
            public int Count
            {
                get
                {
                    return base.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IDColumn
            {
                get
                {
                    return this.columnID;
                }
            }

            [DebuggerNonUserCode]
            public Info.QuestionRow this[int index]
            {
                get
                {
                    return (Info.QuestionRow) base.Rows[index];
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NumColumn
            {
                get
                {
                    return this.columnNum;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class QuestionRow : DataRow
        {
            private Info.QuestionDataTable tableQuestion;

            [DebuggerNonUserCode]
            internal QuestionRow(DataRowBuilder rb) : base(rb)
            {
                this.tableQuestion = (Info.QuestionDataTable) base.Table;
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow[] GetUserAnswersRows()
            {
                if (base.Table.ChildRelations["FK_Question_UserAnswers"] == null)
                {
                    return new Info.UserAnswersRow[0];
                }
                return (Info.UserAnswersRow[]) base.GetChildRows(base.Table.ChildRelations["FK_Question_UserAnswers"]);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return base.IsNull(this.tableQuestion.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNumNull()
            {
                return base.IsNull(this.tableQuestion.NumColumn);
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                base[this.tableQuestion.NameColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetNumNull()
            {
                base[this.tableQuestion.NumColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public short ID
            {
                get
                {
                    return (short) base[this.tableQuestion.IDColumn];
                }
                set
                {
                    base[this.tableQuestion.IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableQuestion.NameColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Name' in table 'Question' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableQuestion.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public short Num
            {
                get
                {
                    short num;
                    try
                    {
                        num = (short) base[this.tableQuestion.NumColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Num' in table 'Question' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableQuestion.NumColumn] = value;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class QuestionRowChangeEvent : EventArgs
        {
            private DataRowAction eventAction;
            private Info.QuestionRow eventRow;

            [DebuggerNonUserCode]
            public QuestionRowChangeEvent(Info.QuestionRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public Info.QuestionRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }
        }

        public delegate void QuestionRowChangeEventHandler(object sender, Info.QuestionRowChangeEvent e);

        [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
        public class UserAnswersDataTable : DataTable, IEnumerable
        {
            private DataColumn columnID;
            private DataColumn columnIS_CHECKED;
            private DataColumn columnIS_CORRECT;
            private DataColumn columnName;
            private DataColumn columnQUESTION_ID;
            private DataColumn columnUSER_ID;

            public event Info.UserAnswersRowChangeEventHandler UserAnswersRowChanged;

            public event Info.UserAnswersRowChangeEventHandler UserAnswersRowChanging;

            public event Info.UserAnswersRowChangeEventHandler UserAnswersRowDeleted;

            public event Info.UserAnswersRowChangeEventHandler UserAnswersRowDeleting;

            [DebuggerNonUserCode]
            public UserAnswersDataTable()
            {
                base.TableName = "UserAnswers";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal UserAnswersDataTable(DataTable table)
            {
                base.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    base.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    base.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    base.Namespace = table.Namespace;
                }
                base.Prefix = table.Prefix;
                base.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected UserAnswersDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
            {
                this.InitVars();
            }

            [DebuggerNonUserCode]
            public void AddUserAnswersRow(Info.UserAnswersRow row)
            {
                base.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow AddUserAnswersRow(string Name, Info.UserRow parentUserRowByFK_User_UserAnswers, Info.QuestionRow parentQuestionRowByFK_Question_UserAnswers, bool IS_CHECKED, bool IS_CORRECT)
            {
                Info.UserAnswersRow row = (Info.UserAnswersRow) base.NewRow();
                object[] objArray2 = new object[6];
                objArray2[1] = Name;
                objArray2[4] = IS_CHECKED;
                objArray2[5] = IS_CORRECT;
                object[] objArray = objArray2;
                if (parentUserRowByFK_User_UserAnswers != null)
                {
                    objArray[2] = parentUserRowByFK_User_UserAnswers[0];
                }
                if (parentQuestionRowByFK_Question_UserAnswers != null)
                {
                    objArray[3] = parentQuestionRowByFK_Question_UserAnswers[0];
                }
                row.ItemArray = objArray;
                base.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                Info.UserAnswersDataTable table = (Info.UserAnswersDataTable) base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new Info.UserAnswersDataTable();
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow FindByID(short ID)
            {
                return (Info.UserAnswersRow) base.Rows.Find(new object[] { ID });
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return base.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(Info.UserAnswersRow);
            }

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                XmlSchemaComplexType type = new XmlSchemaComplexType();
                XmlSchemaSequence sequence = new XmlSchemaSequence();
                Info info = new Info();
                XmlSchemaAny item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                item.MinOccurs = 0M;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                XmlSchemaAny any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                any2.MinOccurs = 1M;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                XmlSchemaAttribute attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = info.Namespace;
                type.Attributes.Add(attribute);
                XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "UserAnswersDataTable";
                type.Attributes.Add(attribute2);
                type.Particle = sequence;
                XmlSchema schemaSerializable = info.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    MemoryStream stream = new MemoryStream();
                    MemoryStream stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema) enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type;
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnID = new DataColumn("ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnID);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnUSER_ID = new DataColumn("USER_ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnUSER_ID);
                this.columnQUESTION_ID = new DataColumn("QUESTION_ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnQUESTION_ID);
                this.columnIS_CHECKED = new DataColumn("IS_CHECKED", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnIS_CHECKED);
                this.columnIS_CORRECT = new DataColumn("IS_CORRECT", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnIS_CORRECT);
                base.Constraints.Add(new UniqueConstraint("UserAnswersPK", new DataColumn[] { this.columnID }, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.Unique = true;
            }

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnID = base.Columns["ID"];
                this.columnName = base.Columns["Name"];
                this.columnUSER_ID = base.Columns["USER_ID"];
                this.columnQUESTION_ID = base.Columns["QUESTION_ID"];
                this.columnIS_CHECKED = base.Columns["IS_CHECKED"];
                this.columnIS_CORRECT = base.Columns["IS_CORRECT"];
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new Info.UserAnswersRow(builder);
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow NewUserAnswersRow()
            {
                return (Info.UserAnswersRow) base.NewRow();
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                if (this.UserAnswersRowChanged != null)
                {
                    this.UserAnswersRowChanged(this, new Info.UserAnswersRowChangeEvent((Info.UserAnswersRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                if (this.UserAnswersRowChanging != null)
                {
                    this.UserAnswersRowChanging(this, new Info.UserAnswersRowChangeEvent((Info.UserAnswersRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                if (this.UserAnswersRowDeleted != null)
                {
                    this.UserAnswersRowDeleted(this, new Info.UserAnswersRowChangeEvent((Info.UserAnswersRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                if (this.UserAnswersRowDeleting != null)
                {
                    this.UserAnswersRowDeleting(this, new Info.UserAnswersRowChangeEvent((Info.UserAnswersRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            public void RemoveUserAnswersRow(Info.UserAnswersRow row)
            {
                base.Rows.Remove(row);
            }

            [DebuggerNonUserCode, Browsable(false)]
            public int Count
            {
                get
                {
                    return base.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IDColumn
            {
                get
                {
                    return this.columnID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IS_CHECKEDColumn
            {
                get
                {
                    return this.columnIS_CHECKED;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IS_CORRECTColumn
            {
                get
                {
                    return this.columnIS_CORRECT;
                }
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow this[int index]
            {
                get
                {
                    return (Info.UserAnswersRow) base.Rows[index];
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn QUESTION_IDColumn
            {
                get
                {
                    return this.columnQUESTION_ID;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn USER_IDColumn
            {
                get
                {
                    return this.columnUSER_ID;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class UserAnswersRow : DataRow
        {
            private Info.UserAnswersDataTable tableUserAnswers;

            [DebuggerNonUserCode]
            internal UserAnswersRow(DataRowBuilder rb) : base(rb)
            {
                this.tableUserAnswers = (Info.UserAnswersDataTable) base.Table;
            }

            [DebuggerNonUserCode]
            public bool IsIS_CHECKEDNull()
            {
                return base.IsNull(this.tableUserAnswers.IS_CHECKEDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsIS_CORRECTNull()
            {
                return base.IsNull(this.tableUserAnswers.IS_CORRECTColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return base.IsNull(this.tableUserAnswers.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsQUESTION_IDNull()
            {
                return base.IsNull(this.tableUserAnswers.QUESTION_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsUSER_IDNull()
            {
                return base.IsNull(this.tableUserAnswers.USER_IDColumn);
            }

            [DebuggerNonUserCode]
            public void SetIS_CHECKEDNull()
            {
                base[this.tableUserAnswers.IS_CHECKEDColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetIS_CORRECTNull()
            {
                base[this.tableUserAnswers.IS_CORRECTColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                base[this.tableUserAnswers.NameColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetQUESTION_IDNull()
            {
                base[this.tableUserAnswers.QUESTION_IDColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetUSER_IDNull()
            {
                base[this.tableUserAnswers.USER_IDColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public short ID
            {
                get
                {
                    return (short) base[this.tableUserAnswers.IDColumn];
                }
                set
                {
                    base[this.tableUserAnswers.IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public bool IS_CHECKED
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = (bool) base[this.tableUserAnswers.IS_CHECKEDColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'IS_CHECKED' in table 'UserAnswers' is DBNull.", exception);
                    }
                    return flag;
                }
                set
                {
                    base[this.tableUserAnswers.IS_CHECKEDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public bool IS_CORRECT
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = (bool) base[this.tableUserAnswers.IS_CORRECTColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'IS_CORRECT' in table 'UserAnswers' is DBNull.", exception);
                    }
                    return flag;
                }
                set
                {
                    base[this.tableUserAnswers.IS_CORRECTColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableUserAnswers.NameColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Name' in table 'UserAnswers' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableUserAnswers.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public short QUESTION_ID
            {
                get
                {
                    short num;
                    try
                    {
                        num = (short) base[this.tableUserAnswers.QUESTION_IDColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'QUESTION_ID' in table 'UserAnswers' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableUserAnswers.QUESTION_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public ICMRemoteEdu.Forms.Info.QuestionRow QuestionRow
            {
                get
                {
                    return (ICMRemoteEdu.Forms.Info.QuestionRow) base.GetParentRow(base.Table.ParentRelations["FK_Question_UserAnswers"]);
                }
                set
                {
                    base.SetParentRow(value, base.Table.ParentRelations["FK_Question_UserAnswers"]);
                }
            }

            [DebuggerNonUserCode]
            public short USER_ID
            {
                get
                {
                    short num;
                    try
                    {
                        num = (short) base[this.tableUserAnswers.USER_IDColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'USER_ID' in table 'UserAnswers' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableUserAnswers.USER_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public ICMRemoteEdu.Forms.Info.UserRow UserRow
            {
                get
                {
                    return (ICMRemoteEdu.Forms.Info.UserRow) base.GetParentRow(base.Table.ParentRelations["FK_User_UserAnswers"]);
                }
                set
                {
                    base.SetParentRow(value, base.Table.ParentRelations["FK_User_UserAnswers"]);
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class UserAnswersRowChangeEvent : EventArgs
        {
            private DataRowAction eventAction;
            private Info.UserAnswersRow eventRow;

            [DebuggerNonUserCode]
            public UserAnswersRowChangeEvent(Info.UserAnswersRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }
        }

        public delegate void UserAnswersRowChangeEventHandler(object sender, Info.UserAnswersRowChangeEvent e);

        [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
        public class UserDataTable : DataTable, IEnumerable
        {
            private DataColumn columnCompany_ID;
            private DataColumn columnID;
            private DataColumn columnName;
            private DataColumn columnPosition;

            public event Info.UserRowChangeEventHandler UserRowChanged;

            public event Info.UserRowChangeEventHandler UserRowChanging;

            public event Info.UserRowChangeEventHandler UserRowDeleted;

            public event Info.UserRowChangeEventHandler UserRowDeleting;

            [DebuggerNonUserCode]
            public UserDataTable()
            {
                base.TableName = "User";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal UserDataTable(DataTable table)
            {
                base.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    base.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    base.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    base.Namespace = table.Namespace;
                }
                base.Prefix = table.Prefix;
                base.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected UserDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
            {
                this.InitVars();
            }

            [DebuggerNonUserCode]
            public void AddUserRow(Info.UserRow row)
            {
                base.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public Info.UserRow AddUserRow(string Name, string Position, short Company_ID)
            {
                Info.UserRow row = (Info.UserRow) base.NewRow();
                object[] objArray2 = new object[4];
                objArray2[1] = Name;
                objArray2[2] = Position;
                objArray2[3] = Company_ID;
                object[] objArray = objArray2;
                row.ItemArray = objArray;
                base.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                Info.UserDataTable table = (Info.UserDataTable) base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new Info.UserDataTable();
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return base.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(Info.UserRow);
            }

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                XmlSchemaComplexType type = new XmlSchemaComplexType();
                XmlSchemaSequence sequence = new XmlSchemaSequence();
                Info info = new Info();
                XmlSchemaAny item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                item.MinOccurs = 0M;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                XmlSchemaAny any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                any2.MinOccurs = 1M;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                XmlSchemaAttribute attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = info.Namespace;
                type.Attributes.Add(attribute);
                XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "UserDataTable";
                type.Attributes.Add(attribute2);
                type.Particle = sequence;
                XmlSchema schemaSerializable = info.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    MemoryStream stream = new MemoryStream();
                    MemoryStream stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema) enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type;
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnID = new DataColumn("ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnID);
                this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnName);
                this.columnPosition = new DataColumn("Position", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnPosition);
                this.columnCompany_ID = new DataColumn("Company_ID", typeof(short), null, MappingType.Element);
                base.Columns.Add(this.columnCompany_ID);
                base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnID }, false));
                this.columnID.AutoIncrement = true;
                this.columnID.Unique = true;
            }

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnID = base.Columns["ID"];
                this.columnName = base.Columns["Name"];
                this.columnPosition = base.Columns["Position"];
                this.columnCompany_ID = base.Columns["Company_ID"];
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new Info.UserRow(builder);
            }

            [DebuggerNonUserCode]
            public Info.UserRow NewUserRow()
            {
                return (Info.UserRow) base.NewRow();
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                if (this.UserRowChanged != null)
                {
                    this.UserRowChanged(this, new Info.UserRowChangeEvent((Info.UserRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                if (this.UserRowChanging != null)
                {
                    this.UserRowChanging(this, new Info.UserRowChangeEvent((Info.UserRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                if (this.UserRowDeleted != null)
                {
                    this.UserRowDeleted(this, new Info.UserRowChangeEvent((Info.UserRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                if (this.UserRowDeleting != null)
                {
                    this.UserRowDeleting(this, new Info.UserRowChangeEvent((Info.UserRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            public void RemoveUserRow(Info.UserRow row)
            {
                base.Rows.Remove(row);
            }

            [DebuggerNonUserCode]
            public DataColumn Company_IDColumn
            {
                get
                {
                    return this.columnCompany_ID;
                }
            }

            [DebuggerNonUserCode, Browsable(false)]
            public int Count
            {
                get
                {
                    return base.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn IDColumn
            {
                get
                {
                    return this.columnID;
                }
            }

            [DebuggerNonUserCode]
            public Info.UserRow this[int index]
            {
                get
                {
                    return (Info.UserRow) base.Rows[index];
                }
            }

            [DebuggerNonUserCode]
            public DataColumn NameColumn
            {
                get
                {
                    return this.columnName;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn PositionColumn
            {
                get
                {
                    return this.columnPosition;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class UserRow : DataRow
        {
            private Info.UserDataTable tableUser;

            [DebuggerNonUserCode]
            internal UserRow(DataRowBuilder rb) : base(rb)
            {
                this.tableUser = (Info.UserDataTable) base.Table;
            }

            [DebuggerNonUserCode]
            public Info.UserAnswersRow[] GetUserAnswersRows()
            {
                if (base.Table.ChildRelations["FK_User_UserAnswers"] == null)
                {
                    return new Info.UserAnswersRow[0];
                }
                return (Info.UserAnswersRow[]) base.GetChildRows(base.Table.ChildRelations["FK_User_UserAnswers"]);
            }

            [DebuggerNonUserCode]
            public bool IsCompany_IDNull()
            {
                return base.IsNull(this.tableUser.Company_IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsIDNull()
            {
                return base.IsNull(this.tableUser.IDColumn);
            }

            [DebuggerNonUserCode]
            public bool IsNameNull()
            {
                return base.IsNull(this.tableUser.NameColumn);
            }

            [DebuggerNonUserCode]
            public bool IsPositionNull()
            {
                return base.IsNull(this.tableUser.PositionColumn);
            }

            [DebuggerNonUserCode]
            public void SetCompany_IDNull()
            {
                base[this.tableUser.Company_IDColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetIDNull()
            {
                base[this.tableUser.IDColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetNameNull()
            {
                base[this.tableUser.NameColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetPositionNull()
            {
                base[this.tableUser.PositionColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public short Company_ID
            {
                get
                {
                    short num;
                    try
                    {
                        num = (short) base[this.tableUser.Company_IDColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Company_ID' in table 'User' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableUser.Company_IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public short ID
            {
                get
                {
                    short num;
                    try
                    {
                        num = (short) base[this.tableUser.IDColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'ID' in table 'User' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableUser.IDColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Name
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableUser.NameColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Name' in table 'User' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableUser.NameColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Position
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableUser.PositionColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Position' in table 'User' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableUser.PositionColumn] = value;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class UserRowChangeEvent : EventArgs
        {
            private DataRowAction eventAction;
            private Info.UserRow eventRow;

            [DebuggerNonUserCode]
            public UserRowChangeEvent(Info.UserRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public Info.UserRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }
        }

        public delegate void UserRowChangeEventHandler(object sender, Info.UserRowChangeEvent e);
    }
}

